41a61536MFhNalgbVmYGXAhQsPTZNw xen/include/asm-x86/multicall.h
3ddb79c3xjYnrv5t3VqYlR4tNEOl4Q xen/include/asm-x86/page.h
3ddb79c3ysKUbxZuwKBRK3WXU2TlEg xen/include/asm-x86/pci.h
-404f1bb41Yl-5ZjIWnG66HDCj6OIWA xen/include/asm-x86/pda.h
4022a73diKn2Ax4-R4gzk59lm1YdDg xen/include/asm-x86/pdb.h
3ddb79c2QF5-pZGzuX4QukPCDAl59A xen/include/asm-x86/processor.h
40cf1596bim9F9DNdV75klgRSZ6Y2A xen/include/asm-x86/regs.h
LD := ld
CFLAGS := -nostdinc -fno-builtin -fno-common -fno-strict-aliasing
-CFLAGS += -iwithprefix include -Wall -Werror -pipe
+CFLAGS += -iwithprefix include -Wall -Werror -Wno-format -pipe
CFLAGS += -I$(BASEDIR)/include -Wno-pointer-arith -Wredundant-decls
ifeq ($(optimize),y)
/* Set up a few descriptors: on entry only CS is guaranteed good. */
lgdt %cs:0x1001f0
- mov $(__HYPERVISOR_DS),%ecx
+ mov $(__HYPERVISOR_DS32),%ecx
mov %ecx,%ds
mov %ecx,%es
- /* Check for Multiboot bootloader */
cmp $(SECONDARY_CPU_FLAG),%ebx
- je skip_multiboot_check
+ je skip_boot_checks
+
+ /* Check for Multiboot bootloader */
cmp $0x2BADB002,%eax
jne not_multiboot
-skip_multiboot_check:
/* Save the Multiboot info structure for later use. */
mov %ebx,0x1001e0
cpuid
bt $29,%edx # Long mode feature?
jnc bad_cpu
-
+skip_boot_checks:
+
/* Set up FPU. */
fninit
ret
__high_start:
+ mov $(__HYPERVISOR_DS64),%ecx
+ mov %ecx,%ds
+ mov %ecx,%es
+ mov %ecx,%fs
+ mov %ecx,%gs
+ mov %ecx,%ss
+
lidt idt_descr(%rip)
cmp $(SECONDARY_CPU_FLAG),%ebx
.quad SYMBOL_NAME(idt_table)
ENTRY(stack_start)
- .quad SYMBOL_NAME(cpu0_stack) + 8100
+ .quad SYMBOL_NAME(cpu0_stack) + 8000
high_start:
.quad __high_start
ENTRY(stext)
ENTRY(_stext)
-.globl switch_to, ret_from_intr, do_iopl
+.globl switch_to, do_iopl
switch_to:
-ret_from_intr:
do_iopl:
.globl copy_from_user, copy_to_user, copy_user_generic, new_thread
copy_from_user:
spin_unlock_irqrestore(&desc->lock, flags);
}
-asmlinkage void do_IRQ(struct xen_regs regs)
+asmlinkage void do_IRQ(struct xen_regs *regs)
{
-#if defined(__i386__)
- unsigned int irq = regs.entry_vector;
-#else
- unsigned int irq = 0; /* XXX */
-#endif
+ unsigned int irq = regs->entry_vector;
irq_desc_t *desc = &irq_desc[irq];
struct irqaction *action;
desc->status &= ~IRQ_PENDING;
irq_enter(smp_processor_id(), irq);
spin_unlock_irq(&desc->lock);
- action->handler(irq, action->dev_id, ®s);
+ action->handler(irq, action->dev_id, regs);
spin_lock_irq(&desc->lock);
irq_exit(smp_processor_id(), irq);
}
* At this point, boot CPU has fully initialised the IDT. It is
* now safe to make ourselves a private copy.
*/
- idt_tables[cpu] = xmalloc_array(struct desc_struct, IDT_ENTRIES);
+ idt_tables[cpu] = xmalloc_array(idt_entry_t, IDT_ENTRIES);
memcpy(idt_tables[cpu], idt_table, IDT_ENTRIES*8);
*(unsigned short *)(&idt_load[0]) = (IDT_ENTRIES*8)-1;
*(unsigned long *)(&idt_load[2]) = (unsigned long)idt_tables[cpu];
struct exec_domain *ed;
unsigned long boot_error = 0;
int timeout, cpu;
- unsigned long start_eip, stack;
+ unsigned long start_eip;
+ void *stack;
cpu = ++cpucount;
/* So we see what's up. */
printk("Booting processor %d/%d eip %lx\n", cpu, apicid, start_eip);
- stack = __pa(alloc_xenheap_pages(1));
- stack_start.esp = stack + STACK_SIZE - STACK_RESERVED;
+ stack = (void *)alloc_xenheap_pages(1);
+#if defined(__i386__)
+ stack_start.esp = __pa(stack) + STACK_SIZE - STACK_RESERVED;
+#elif defined(__x86_64__)
+ stack_start.esp = (unsigned long)stack + STACK_SIZE - STACK_RESERVED;
+#endif
/* Debug build: detect stack overflow by setting up a guard page. */
- memguard_guard_range(__va(stack), PAGE_SIZE);
+ memguard_guard_range(stack, PAGE_SIZE);
/*
* This grunge runs the startup process for
printk("CPU%d has booted.\n", cpu);
} else {
boot_error= 1;
- if (*((volatile unsigned long *)phys_to_virt(start_eip))
+ if (*((volatile unsigned int *)phys_to_virt(start_eip))
== 0xA5A5A5A5)
/* trampoline started but...? */
printk("Stuck ??\n");
if ( trapnr == TRAP_page_fault )
{
__asm__ __volatile__ ("mov %%cr2,%0" : "=r" (cr2) : );
- printk("Faulting linear address might be %08lx\n", cr2);
+ printk("Faulting linear address might be %0lx %lx\n", cr2, cr2);
}
printk("************************************\n");
if ( likely((fixup = search_exception_table(regs->eip)) != 0) )
{
- DPRINTK("Trap %d: %08lx -> %08lx\n", trapnr, regs->eip, fixup);
+ DPRINTK("Trap %d: %p -> %p\n", trapnr, regs->eip, fixup);
regs->eip = fixup;
return 0;
}
{
perfc_incrc(copy_user_faults);
if ( !ed->mm.shadow_mode )
- DPRINTK("Page fault: %08lx -> %08lx\n", regs->eip, fixup);
+ DPRINTK("Page fault: %p -> %p\n", regs->eip, fixup);
regs->eip = fixup;
return 0;
}
{
unsigned long page;
page = l2_pgentry_val(idle_pg_table[addr >> L2_PAGETABLE_SHIFT]);
- printk("*pde = %08lx\n", page);
+ printk("*pde = %p\n", page);
if ( page & _PAGE_PRESENT )
{
page &= PAGE_MASK;
page = ((unsigned long *) __va(page))[(addr&0x3ff000)>>PAGE_SHIFT];
- printk(" *pte = %08lx\n", page);
+ printk(" *pte = %p\n", page);
}
#ifdef MEMORY_GUARD
if ( !(regs->error_code & 1) )
show_registers(regs);
panic("CPU%d FATAL PAGE FAULT\n"
"[error_code=%04x]\n"
- "Faulting linear address might be %08lx\n",
+ "Faulting linear address might be %p\n",
smp_processor_id(), regs->error_code, addr);
return 0;
}
if ( likely((fixup = search_exception_table(regs->eip)) != 0) )
{
- DPRINTK("GPF (%04x): %08lx -> %08lx\n",
+ DPRINTK("GPF (%04x): %p -> %p\n",
regs->error_code, regs->eip, fixup);
regs->eip = fixup;
return 0;
idt_table[n].b = 0x8500;
}
-#define _set_seg_desc(gate_addr,type,dpl,base,limit) {\
- *((gate_addr)+1) = ((base) & 0xff000000) | \
- (((base) & 0x00ff0000)>>16) | \
- ((limit) & 0xf0000) | \
- ((dpl)<<13) | \
- (0x00408000) | \
- ((type)<<8); \
- *(gate_addr) = (((base) & 0x0000ffff)<<16) | \
- ((limit) & 0x0ffff); }
-
void set_tss_desc(unsigned int n, void *addr)
{
_set_tssldt_desc(
extern void doublefault_init(void);
doublefault_init();
-#ifdef __i386__
/*
* Note that interrupt gates are always used, rather than trap gates. We
* must have interrupts disabled until DS/ES/FS/GS are saved because the
set_intr_gate(TRAP_simd_error,&simd_coprocessor_error);
set_intr_gate(TRAP_deferred_nmi,&nmi);
- /* Only ring 1 can access Xen services. */
- _set_gate(idt_table+HYPERCALL_VECTOR,14,1,&hypercall);
+#if defined(__i386__)
+ _set_gate(idt_table+HYPERCALL_VECTOR, 14, 1, &hypercall);
+#elif defined(__x86_64__)
+ _set_gate(idt_table+HYPERCALL_VECTOR, 14, 3, &hypercall);
#endif
/* CPU0 uses the master IDT. */
int i;
execution_context_t *ec = get_execution_context();
unsigned long *stack = (unsigned long *)ec->esp;
- printk("Guest EIP is %lx\n",ec->eip);
+ printk("Guest EIP is %lx\n ",ec->eip);
for ( i = 0; i < kstack_depth_to_print; i++ )
{
if ( ((long)stack & (STACK_SIZE-1)) == 0 )
break;
if ( i && ((i % 8) == 0) )
- printk("\n ");
- printk("%08lx ", *stack++);
+ printk("\n ");
+ printk("%p ", *stack++);
}
printk("\n");
unsigned long *stack, addr;
int i;
- printk("Call Trace from ESP=%p: ", esp);
+ printk("Call Trace from ESP=%p:\n ", esp);
stack = esp;
i = 0;
while (((long) stack & (STACK_SIZE-1)) != 0) {
if (kernel_text_address(addr)) {
if (i && ((i % 6) == 0))
printk("\n ");
- printk("[<%08lx>] ", addr);
+ printk("[<%p>] ", addr);
i++;
}
}
unsigned long *stack;
int i;
- printk("Stack trace from ESP=%p:\n", esp);
+ printk("Stack trace from ESP=%p:\n ", esp);
stack = esp;
for ( i = 0; i < kstack_depth_to_print; i++ )
if ( ((long)stack & (STACK_SIZE-1)) == 0 )
break;
if ( i && ((i % 8) == 0) )
- printk("\n ");
+ printk("\n ");
if ( kernel_text_address(*stack) )
- printk("[%08lx] ", *stack++);
+ printk("[%p] ", *stack++);
else
- printk("%08lx ", *stack++);
+ printk("%p ", *stack++);
}
printk("\n");
gs = __HYPERVISOR_DS;
}
- printk("CPU: %d\nEIP: %04lx:[<%08lx>] \nEFLAGS: %08lx\n",
+ printk("CPU: %d\nEIP: %04lx:[<%p>] \nEFLAGS: %p\n",
smp_processor_id(), 0xffff & regs->cs, regs->eip, regs->eflags);
- printk("eax: %08lx ebx: %08lx ecx: %08lx edx: %08lx\n",
+ printk("eax: %p ebx: %p ecx: %p edx: %p\n",
regs->eax, regs->ebx, regs->ecx, regs->edx);
- printk("esi: %08lx edi: %08lx ebp: %08lx esp: %08lx\n",
+ printk("esi: %p edi: %p ebp: %p esp: %p\n",
regs->esi, regs->edi, regs->ebp, esp);
printk("ds: %04x es: %04x fs: %04x gs: %04x ss: %04x\n",
ds, es, fs, gs, ss);
+/*
+ * Hypercall and fault low-level handling routines.
+ *
+ * Copyright (c) 2005, K A Fraser
+ */
+
+#include <xen/config.h>
+#include <xen/errno.h>
+#include <xen/softirq.h>
+#include <asm/asm_defns.h>
+#include <asm/apicdef.h>
+#include <public/xen.h>
+
+ENTRY(hypercall)
+ iret
+
+ENTRY(ret_from_intr)
+restore_all_xen:
+ popq %r15
+ popq %r14
+ popq %r13
+ popq %r12
+ popq %rbp
+ popq %rbx
+ popq %r11
+ popq %r10
+ popq %r9
+ popq %r8
+ popq %rax
+ popq %rcx
+ popq %rdx
+ popq %rsi
+ popq %rdi
+ addq $8,%rsp
+ iret
+
+error_code:
+ SAVE_ALL
+ movq %rsp,%rdi
+ movl XREGS_entry_vector(%rsp),%eax
+ leaq SYMBOL_NAME(exception_table)(%rip),%rdx
+ callq *(%rdx,%rax,8)
+ jmp restore_all_xen
+
+ENTRY(divide_error)
+ pushq $0
+ movl $TRAP_divide_error,4(%rsp)
+ jmp error_code
+
+ENTRY(coprocessor_error)
+ pushq $0
+ movl $TRAP_copro_error,4(%rsp)
+ jmp error_code
+
+ENTRY(simd_coprocessor_error)
+ pushq $0
+ movl $TRAP_simd_error,4(%rsp)
+ jmp error_code
+
+ENTRY(device_not_available)
+ pushq $0
+ movl $TRAP_no_device,4(%rsp)
+ jmp error_code
+
+ENTRY(debug)
+ pushq $0
+ movl $TRAP_debug,4(%rsp)
+ jmp error_code
+
+ENTRY(int3)
+ pushq $0
+ movl $TRAP_int3,4(%rsp)
+ jmp error_code
+
+ENTRY(overflow)
+ pushq $0
+ movl $TRAP_overflow,4(%rsp)
+ jmp error_code
+
+ENTRY(bounds)
+ pushq $0
+ movl $TRAP_bounds,4(%rsp)
+ jmp error_code
+
+ENTRY(invalid_op)
+ pushq $0
+ movl $TRAP_invalid_op,4(%rsp)
+ jmp error_code
+
+ENTRY(coprocessor_segment_overrun)
+ pushq $0
+ movl $TRAP_copro_seg,4(%rsp)
+ jmp error_code
+
+ENTRY(invalid_TSS)
+ movl $TRAP_invalid_tss,4(%rsp)
+ jmp error_code
+
+ENTRY(segment_not_present)
+ movl $TRAP_no_segment,4(%rsp)
+ jmp error_code
+
+ENTRY(stack_segment)
+ movl $TRAP_stack_error,4(%rsp)
+ jmp error_code
+
+ENTRY(general_protection)
+ movl $TRAP_gp_fault,4(%rsp)
+ jmp error_code
+
+ENTRY(alignment_check)
+ movl $TRAP_alignment_check,4(%rsp)
+ jmp error_code
+
+ENTRY(page_fault)
+ movl $TRAP_page_fault,4(%rsp)
+ jmp error_code
+
+ENTRY(machine_check)
+ pushq $0
+ movl $TRAP_machine_check,4(%rsp)
+ jmp error_code
+
+ENTRY(spurious_interrupt_bug)
+ pushq $0
+ movl $TRAP_spurious_int,4(%rsp)
+ jmp error_code
+
+ENTRY(nmi)
+ iret
+
+.data
+
+ENTRY(exception_table)
+ .quad SYMBOL_NAME(do_divide_error)
+ .quad SYMBOL_NAME(do_debug)
+ .quad 0 # nmi
+ .quad SYMBOL_NAME(do_int3)
+ .quad SYMBOL_NAME(do_overflow)
+ .quad SYMBOL_NAME(do_bounds)
+ .quad SYMBOL_NAME(do_invalid_op)
+ .quad SYMBOL_NAME(math_state_restore)
+ .quad 0 # double fault
+ .quad SYMBOL_NAME(do_coprocessor_segment_overrun)
+ .quad SYMBOL_NAME(do_invalid_TSS)
+ .quad SYMBOL_NAME(do_segment_not_present)
+ .quad SYMBOL_NAME(do_stack_segment)
+ .quad SYMBOL_NAME(do_general_protection)
+ .quad SYMBOL_NAME(do_page_fault)
+ .quad SYMBOL_NAME(do_spurious_interrupt_bug)
+ .quad SYMBOL_NAME(do_coprocessor_error)
+ .quad SYMBOL_NAME(do_alignment_check)
+ .quad SYMBOL_NAME(do_machine_check)
+ .quad SYMBOL_NAME(do_simd_coprocessor_error)
int i;
execution_context_t *ec = get_execution_context();
unsigned long *stack = (unsigned long *)ec->rsp;
- printk("Guest RIP is %lx\n", ec->rip);
+ printk("Guest RIP is %lx\n ", ec->rip);
for ( i = 0; i < kstack_depth_to_print; i++ )
{
if ( ((long)stack & (STACK_SIZE-1)) == 0 )
break;
if ( i && ((i % 8) == 0) )
- printk("\n ");
- printk("%08lx ", *stack++);
+ printk("\n ");
+ printk("%p ", *stack++);
}
printk("\n");
unsigned long *stack, addr;
int i;
- printk("Call Trace from RSP=%p: ", rsp);
+ printk("Call Trace from RSP=%p:\n ", rsp);
stack = rsp;
i = 0;
while (((long) stack & (STACK_SIZE-1)) != 0) {
if (kernel_text_address(addr)) {
if (i && ((i % 6) == 0))
printk("\n ");
- printk("[<%08lx>] ", addr);
+ printk("[<%p>] ", addr);
i++;
}
}
unsigned long *stack;
int i;
- printk("Stack trace from RSP=%p:\n", rsp);
+ printk("Stack trace from RSP=%p:\n ", rsp);
stack = rsp;
for ( i = 0; i < kstack_depth_to_print; i++ )
if ( ((long)stack & (STACK_SIZE-1)) == 0 )
break;
if ( i && ((i % 8) == 0) )
- printk("\n ");
+ printk("\n ");
if ( kernel_text_address(*stack) )
- printk("[%08lx] ", *stack++);
+ printk("[%p] ", *stack++);
else
- printk("%08lx ", *stack++);
+ printk("%p ", *stack++);
}
printk("\n");
void show_registers(struct xen_regs *regs)
{
- printk("CPU: %d\nEIP: %04lx:[<%08lx>] \nEFLAGS: %08lx\n",
+ printk("CPU: %d\nEIP: %04lx:[<%p>] \nEFLAGS: %p\n",
smp_processor_id(), 0xffff & regs->cs, regs->rip, regs->eflags);
- printk("rax: %08lx rbx: %08lx rcx: %08lx rdx: %08lx\n",
+ printk("rax: %p rbx: %p rcx: %p rdx: %p\n",
regs->rax, regs->rbx, regs->rcx, regs->rdx);
- printk("rsi: %08lx rdi: %08lx rbp: %08lx rsp: %08lx ss: %04x\n",
- regs->rsi, regs->rdi, regs->rbp, regs->rsp, regs->ss);
- printk("r8: %08lx r9: %08lx r10: %08lx r11: %08lx\n",
+ printk("rsi: %p rdi: %p rbp: %p rsp: %p\n",
+ regs->rsi, regs->rdi, regs->rbp, regs->rsp);
+ printk("r8: %p r9: %p r10: %p r11: %p\n",
regs->r8, regs->r9, regs->r10, regs->r11);
- printk("r12: %08lx r13: %08lx r14: %08lx r15: %08lx\n",
+ printk("r12: %p r13: %p r14: %p r15: %p\n",
regs->r12, regs->r13, regs->r14, regs->r15);
show_stack((unsigned long *)regs->rsp);
#define NR_CPUS 16
/* Linkage for x86 */
-#define asmlinkage __attribute__((regparm(0)))
#define __ALIGN .align 16,0x90
#define __ALIGN_STR ".align 16,0x90"
#define SYMBOL_NAME_STR(X) #X
#if defined(__x86_64__)
+#define asmlinkage
+
#define XENHEAP_DEFAULT_MB (16)
#define PML4_ENTRY_BITS 39
#define __HYPERVISOR_CS64 0x0810
#define __HYPERVISOR_CS32 0x0808
-#define __HYPERVISOR_DS 0x0818
+#define __HYPERVISOR_CS __HYPERVISOR_CS64
+#define __HYPERVISOR_DS64 0x0000
+#define __HYPERVISOR_DS32 0x0818
+#define __HYPERVISOR_DS __HYPERVISOR_DS64
/* For generic assembly code: use macros to define operation/operand sizes. */
#define __OS "q" /* Operation Suffix */
#elif defined(__i386__)
+#define asmlinkage __attribute__((regparm(0)))
+
#define XENHEAP_DEFAULT_MB (12)
#define DIRECTMAP_PHYS_END (12*1024*1024)
u64 a, b;
} idt_entry_t;
-#define _set_gate(gate_addr,type,dpl,addr) ((void)0)
+#define _set_gate(gate_addr,type,dpl,addr) \
+do { \
+ (gate_addr)->a = \
+ (((unsigned long)(addr) & 0xFFFF0000UL) << 32) | \
+ ((unsigned long)(dpl) << 45) | \
+ ((unsigned long)(type) << 40) | \
+ ((unsigned long)(addr) & 0xFFFFUL) | \
+ ((unsigned long)__HYPERVISOR_CS64 << 16) | \
+ (1UL << 47); \
+ (gate_addr)->b = \
+ ((unsigned long)(addr) >> 32); \
+} while (0)
+
#define _set_tssldt_desc(n,addr,limit,type) ((void)0)
#elif defined(__i386__)
* IDT vectors usable for external interrupt sources start
* at 0x20:
*/
-#define FIRST_EXTERNAL_VECTOR 0x30
+#define FIRST_EXTERNAL_VECTOR 0x30
#define NR_IRQS (256 - FIRST_EXTERNAL_VECTOR)
-#define HYPERCALL_VECTOR 0x82
+#define HYPERCALL_VECTOR 0x82
/*
* Vectors 0x30-0x3f are used for ISA interrupts.
/*
* Special IRQ vectors used by the SMP architecture, 0xf0-0xff
*/
-#define SPURIOUS_APIC_VECTOR 0xff
-#define ERROR_APIC_VECTOR 0xfe
-#define INVALIDATE_TLB_VECTOR 0xfd
-#define EVENT_CHECK_VECTOR 0xfc
-#define CALL_FUNCTION_VECTOR 0xfb
-#define KDB_VECTOR 0xfa
+#define SPURIOUS_APIC_VECTOR 0xff
+#define ERROR_APIC_VECTOR 0xfe
+#define INVALIDATE_TLB_VECTOR 0xfd
+#define EVENT_CHECK_VECTOR 0xfc
+#define CALL_FUNCTION_VECTOR 0xfb
+#define KDB_VECTOR 0xfa
/*
* Local APIC timer IRQ vector is on a different priority level,
* to work around the 'lost local interrupt if more than 2 IRQ
* sources per level' errata.
*/
-#define LOCAL_TIMER_VECTOR 0xef
+#define LOCAL_TIMER_VECTOR 0xef
/*
* First APIC vector available to drivers: (vectors 0x40-0xee)
* we start at 0x41 to spread out vectors evenly between priority
* levels. (0x82 is the hypercall vector)
*/
-#define FIRST_DEVICE_VECTOR 0x41
-#define FIRST_SYSTEM_VECTOR 0xef
+#define FIRST_DEVICE_VECTOR 0x41
+#define FIRST_SYSTEM_VECTOR 0xef
extern int irq_vector[NR_IRQS];
-#define IO_APIC_VECTOR(irq) irq_vector[irq]
+#define IO_APIC_VECTOR(irq) irq_vector[irq]
/*
* Various low-level irq details needed by irq.c, process.c,
#define IO_APIC_IRQ(x) (((x) >= 16) || ((1<<(x)) & io_apic_irqs))
-#define BUILD_SMP_INTERRUPT(x,v) XBUILD_SMP_INTERRUPT(x,v)
-#define XBUILD_SMP_INTERRUPT(x,v)\
-asmlinkage void x(void); \
-asmlinkage void call_##x(void); \
-__asm__( \
-"\n"__ALIGN_STR"\n" \
-SYMBOL_NAME_STR(x) ":\n\t" \
- "push"__OS" $"#v"<<16\n\t" \
- SAVE_ALL(a) \
- SYMBOL_NAME_STR(call_##x)":\n\t" \
- "call "SYMBOL_NAME_STR(smp_##x)"\n\t" \
- "jmp ret_from_intr\n");
-
-#define BUILD_SMP_TIMER_INTERRUPT(x,v) XBUILD_SMP_TIMER_INTERRUPT(x,v)
-#define XBUILD_SMP_TIMER_INTERRUPT(x,v) \
-asmlinkage void x(struct xen_regs * regs); \
-asmlinkage void call_##x(void); \
-__asm__( \
-"\n"__ALIGN_STR"\n" \
-SYMBOL_NAME_STR(x) ":\n\t" \
- "push"__OS" $"#v"<<16\n\t" \
- SAVE_ALL(a) \
- "mov %"__OP"sp,%"__OP"ax\n\t" \
- "push %"__OP"ax\n\t" \
- SYMBOL_NAME_STR(call_##x)":\n\t" \
- "call "SYMBOL_NAME_STR(smp_##x)"\n\t" \
- "add $4,%"__OP"sp\n\t" \
- "jmp ret_from_intr\n");
-
-#define BUILD_COMMON_IRQ() \
-asmlinkage void call_do_IRQ(void); \
-__asm__( \
- "\n" __ALIGN_STR"\n" \
- "common_interrupt:\n\t" \
- SAVE_ALL(a) \
- SYMBOL_NAME_STR(call_do_IRQ)":\n\t" \
- "call " SYMBOL_NAME_STR(do_IRQ) "\n\t" \
- "jmp ret_from_intr\n");
-
-#define IRQ_NAME2(nr) nr##_interrupt(void)
-#define IRQ_NAME(nr) IRQ_NAME2(IRQ##nr)
-
-#define BUILD_IRQ(nr) \
-asmlinkage void IRQ_NAME(nr); \
-__asm__( \
-"\n"__ALIGN_STR"\n" \
-SYMBOL_NAME_STR(IRQ) #nr "_interrupt:\n\t" \
- "push"__OS" $"#nr"<<16\n\t" \
- "jmp common_interrupt");
-
#include <xen/irq.h>
static inline void hw_resend_irq(struct hw_interrupt_type *h, unsigned int i)
{
#if defined(CONFIG_X86_IO_APIC)
- if (IO_APIC_IRQ(i))
- send_IPI_self(IO_APIC_VECTOR(i));
+ if (IO_APIC_IRQ(i))
+ send_IPI_self(IO_APIC_VECTOR(i));
#endif
}
+++ /dev/null
-#ifndef X86_64_PDA_H
-#define X86_64_PDA_H
-
-#include <xen/cache.h>
-
-/* Per processor datastructure. %gs points to it while the kernel runs */
-/* To use a new field with the *_pda macros it needs to be added to tools/offset.c */
-struct x8664_pda {
- unsigned long kernelstack; /* TOS for current process */
- unsigned long oldrsp; /* user rsp for system call */
- unsigned long irqrsp; /* Old rsp for interrupts. */
- struct exec_domain *pcurrent; /* Current process */
- int irqcount; /* Irq nesting counter. Starts with -1 */
- int cpunumber; /* Logical CPU number */
- char *irqstackptr; /* top of irqstack */
- unsigned long volatile *level4_pgt;
-} __cacheline_aligned;
-
-#define PDA_STACKOFFSET (5*8)
-
-#define IRQSTACK_ORDER 2
-#define IRQSTACKSIZE (PAGE_SIZE << IRQSTACK_ORDER)
-
-extern struct x8664_pda cpu_pda[];
-
-/*
- * There is no fast way to get the base address of the PDA, all the accesses
- * have to mention %fs/%gs. So it needs to be done this Torvaldian way.
- */
-#define sizeof_field(type,field) (sizeof(((type *)0)->field))
-#define typeof_field(type,field) typeof(((type *)0)->field)
-
-extern void __bad_pda_field(void);
-/* Don't use offsetof because it requires too much infrastructure */
-#define pda_offset(field) ((unsigned long)&((struct x8664_pda *)0)->field)
-
-#define pda_to_op(op,field,val) do { \
- switch (sizeof_field(struct x8664_pda, field)) { \
- case 2: asm volatile(op "w %0,%%gs:%P1" :: "r" (val), "i"(pda_offset(field)):"memory"); break; \
- case 4: asm volatile(op "l %0,%%gs:%P1" :: "r" (val), "i"(pda_offset(field)):"memory"); break; \
- case 8: asm volatile(op "q %0,%%gs:%P1" :: "r" (val), "i"(pda_offset(field)):"memory"); break; \
- default: __bad_pda_field(); \
- } \
- } while (0)
-
-
-#define pda_from_op(op,field) ({ \
- typedef typeof_field(struct x8664_pda, field) T__; T__ ret__; \
- switch (sizeof_field(struct x8664_pda, field)) { \
- case 2: asm volatile(op "w %%gs:%P1,%0":"=r" (ret__): "i" (pda_offset(field)):"memory"); break; \
- case 4: asm volatile(op "l %%gs:%P1,%0":"=r" (ret__): "i" (pda_offset(field)):"memory"); break; \
- case 8: asm volatile(op "q %%gs:%P1,%0":"=r" (ret__): "i" (pda_offset(field)):"memory"); break; \
- default: __bad_pda_field(); \
- } \
- ret__; })
-
-
-#define read_pda(field) pda_from_op("mov",field)
-#define write_pda(field,val) pda_to_op("mov",field,val)
-#define add_pda(field,val) pda_to_op("add",field,val)
-#define sub_pda(field,val) pda_to_op("sub",field,val)
-
-#endif
* so this is correct in the x86 case.
*/
-#if defined(__i386__)
#define smp_processor_id() (current->processor)
-#elif defined(__x86_64__)
-#include <asm/pda.h>
-#define smp_processor_id() read_pda(cpunumber)
-#endif
static __inline int hard_smp_processor_id(void)
{
#endif
+#define BUILD_SMP_INTERRUPT(x,v) XBUILD_SMP_INTERRUPT(x,v)
+#define XBUILD_SMP_INTERRUPT(x,v)\
+asmlinkage void x(void); \
+__asm__( \
+ "\n"__ALIGN_STR"\n" \
+ SYMBOL_NAME_STR(x) ":\n\t" \
+ "pushl $"#v"<<16\n\t" \
+ SAVE_ALL(a) \
+ "call "SYMBOL_NAME_STR(smp_##x)"\n\t" \
+ "jmp ret_from_intr\n");
+
+#define BUILD_SMP_TIMER_INTERRUPT(x,v) XBUILD_SMP_TIMER_INTERRUPT(x,v)
+#define XBUILD_SMP_TIMER_INTERRUPT(x,v) \
+asmlinkage void x(struct xen_regs * regs); \
+__asm__( \
+"\n"__ALIGN_STR"\n" \
+SYMBOL_NAME_STR(x) ":\n\t" \
+ "pushl $"#v"<<16\n\t" \
+ SAVE_ALL(a) \
+ "movl %esp,%eax\n\t" \
+ "pushl %eax\n\t" \
+ "call "SYMBOL_NAME_STR(smp_##x)"\n\t" \
+ "addl $4,%esp\n\t" \
+ "jmp ret_from_intr\n");
+
+#define BUILD_COMMON_IRQ() \
+__asm__( \
+ "\n" __ALIGN_STR"\n" \
+ "common_interrupt:\n\t" \
+ SAVE_ALL(a) \
+ "movl %esp,%eax\n\t" \
+ "pushl %eax\n\t" \
+ "call " SYMBOL_NAME_STR(do_IRQ) "\n\t" \
+ "addl $4,%esp\n\t" \
+ "jmp ret_from_intr\n");
+
+#define IRQ_NAME2(nr) nr##_interrupt(void)
+#define IRQ_NAME(nr) IRQ_NAME2(IRQ##nr)
+
+#define BUILD_IRQ(nr) \
+asmlinkage void IRQ_NAME(nr); \
+__asm__( \
+"\n"__ALIGN_STR"\n" \
+SYMBOL_NAME_STR(IRQ) #nr "_interrupt:\n\t" \
+ "pushl $"#nr"<<16\n\t" \
+ "jmp common_interrupt");
+
#endif /* __X86_32_ASM_DEFNS_H__ */
#ifndef __X86_64_ASM_DEFNS_H__
#define __X86_64_ASM_DEFNS_H__
-#define SAVE_ALL(_r) ""
+/* Maybe auto-generate the following two cases (quoted vs. unquoted). */
+#ifndef __ASSEMBLY__
+
+#define SAVE_ALL \
+ "cld;" \
+ "pushq %rdi;" \
+ "pushq %rsi;" \
+ "pushq %rdx;" \
+ "pushq %rcx;" \
+ "pushq %rax;" \
+ "pushq %r8;" \
+ "pushq %r9;" \
+ "pushq %r10;" \
+ "pushq %r11;" \
+ "pushq %rbx;" \
+ "pushq %rbp;" \
+ "pushq %r12;" \
+ "pushq %r13;" \
+ "pushq %r14;" \
+ "pushq %r15;"
+
+#else
+
+#define SAVE_ALL \
+ cld; \
+ pushq %rdi; \
+ pushq %rsi; \
+ pushq %rdx; \
+ pushq %rcx; \
+ pushq %rax; \
+ pushq %r8; \
+ pushq %r9; \
+ pushq %r10; \
+ pushq %r11; \
+ pushq %rbx; \
+ pushq %rbp; \
+ pushq %r12; \
+ pushq %r13; \
+ pushq %r14; \
+ pushq %r15;
+
+#endif
+
+#define BUILD_SMP_INTERRUPT(x,v) XBUILD_SMP_INTERRUPT(x,v)
+#define XBUILD_SMP_INTERRUPT(x,v)\
+asmlinkage void x(void); \
+__asm__( \
+ "\n"__ALIGN_STR"\n" \
+ SYMBOL_NAME_STR(x) ":\n\t" \
+ "pushq $0\n\t" \
+ "movl $"#v",4(%rsp)\n\t" \
+ SAVE_ALL \
+ "callq "SYMBOL_NAME_STR(smp_##x)"\n\t" \
+ "jmp ret_from_intr\n");
+
+#define BUILD_SMP_TIMER_INTERRUPT(x,v) XBUILD_SMP_TIMER_INTERRUPT(x,v)
+#define XBUILD_SMP_TIMER_INTERRUPT(x,v) \
+asmlinkage void x(struct xen_regs * regs); \
+__asm__( \
+"\n"__ALIGN_STR"\n" \
+SYMBOL_NAME_STR(x) ":\n\t" \
+ "pushq $0\n\t" \
+ "movl $"#v",4(%rsp)\n\t" \
+ SAVE_ALL \
+ "movq %rsp,%rdi\n\t" \
+ "callq "SYMBOL_NAME_STR(smp_##x)"\n\t" \
+ "jmp ret_from_intr\n");
+
+#define BUILD_COMMON_IRQ() \
+__asm__( \
+ "\n" __ALIGN_STR"\n" \
+ "common_interrupt:\n\t" \
+ SAVE_ALL \
+ "movq %rsp,%rdi\n\t" \
+ "callq " SYMBOL_NAME_STR(do_IRQ) "\n\t" \
+ "jmp ret_from_intr\n");
+
+#define IRQ_NAME2(nr) nr##_interrupt(void)
+#define IRQ_NAME(nr) IRQ_NAME2(IRQ##nr)
+
+#define BUILD_IRQ(nr) \
+asmlinkage void IRQ_NAME(nr); \
+__asm__( \
+"\n"__ALIGN_STR"\n" \
+SYMBOL_NAME_STR(IRQ) #nr "_interrupt:\n\t" \
+ "pushq $0\n\t" \
+ "movl $"#nr",4(%rsp)\n\t" \
+ "jmp common_interrupt");
#endif /* __X86_64_ASM_DEFNS_H__ */
#ifndef _X86_64_CURRENT_H
#define _X86_64_CURRENT_H
-#if !defined(__ASSEMBLY__)
struct domain;
-#include <asm/pda.h>
-
#define STACK_RESERVED \
- (sizeof(execution_context_t))
+ (sizeof(execution_context_t) + sizeof(struct domain *))
static inline struct exec_domain *get_current(void)
{
struct exec_domain *ed;
- ed = read_pda(pcurrent);
+ __asm__ ( "orq %%rsp,%0; andq $~7,%0; movq (%0),%0"
+ : "=r" (ed) : "0" (STACK_SIZE-8) );
return ed;
}
static inline void set_current(struct exec_domain *ed)
{
- write_pda(pcurrent, ed);
+ __asm__ ( "orq %%rsp,%0; andq $~7,%0; movq %1,(%0)"
+ : : "r" (STACK_SIZE-8), "r" (ed) );
}
static inline execution_context_t *get_execution_context(void)
#define schedule_tail(_d) ((_d)->thread.schedule_tail)(_d)
-#else
-
-#ifndef ASM_OFFSET_H
-#include <asm/offset.h>
-#endif
-
-#define GET_CURRENT(reg) movq %gs:(pda_pcurrent),reg
-
-#endif
-
#endif /* !(_X86_64_CURRENT_H) */
projects / xen.git / commitdiff